// create.ts
import Toast from 'tdesign-miniprogram/toast/index';
import Dialog from 'tdesign-miniprogram/dialog/index';

// 阿里云文生图风格映射
const IMAGE_STYLES = {
  '<auto>': '自动',
  '<photography>': '摄影',
  '<portrait>': '人像写真',
  '<3d cartoon>': '3D卡通',
  '<anime>': '动画',
  '<oil painting>': '油画',
  '<watercolor>': '水彩',
  '<sketch>': '素描',
  '<chinese painting>': '中国画',
  '<flat illustration>': '扁平插画'
};

// 图像尺寸选项
const IMAGE_SIZES = ['1024*1024', '720*1280', '768*1152', '1280*720'];

// 云开发环境ID
const ENV_ID = 'cloud1-1gphd2vt3783c2f9';

// 轮询间隔时间（毫秒）
const POLL_INTERVAL = 2000;
// 最大轮询次数
const MAX_POLL_COUNT = 30;

interface ImageData {
  id?: number;
  imageUrl: string;
  promptText: string;
  negativePromptText?: string;
  _id?: string;
  _openid?: string;
  createTime?: number;
  isPublic?: boolean;
  // 新增字段
  taskId?: string;  // 阿里云任务ID
  style?: string;   // 图片风格
  size?: string;    // 图片尺寸
}

Page({
  data: {
    promptText: '',
    negativePromptText: '',
    previewImageUrl: '',
    isGenerating: false,
    currentImageData: null as ImageData | null,
    isPublishing: false,
    openid: '',
    // 新增字段
    currentTaskId: '', // 当前任务ID
    pollCount: 0,      // 轮询次数
    style: '<auto>',   // 默认图片风格
    size: '1024*1024', // 默认图片尺寸
    generationError: ''// 生成错误信息
  },

  onLoad() {
    // 初始化云环境
    this.initCloud();
  },

  // 初始化云开发环境
  async initCloud() {
    try {
      // 初始化云环境
      if (!wx.cloud) {
        console.error('请使用 2.2.3 或以上的基础库以使用云能力');
        return;
      }
      
      wx.cloud.init({
        env: ENV_ID,
        traceUser: true,
      });
      
      // 获取用户openid
      await this.getOpenId();
      
    } catch (error) {
      console.error('初始化云环境失败', error);
      wx.showToast({
        title: '初始化云环境失败',
        icon: 'none'
      });
    }
  },
  
  // 获取用户openid
  async getOpenId() {
    try {
      const loginRes = await wx.cloud.callFunction({
        name: 'login'
      }) as any;
      
      if (loginRes && loginRes.result && loginRes.result.openid) {
        this.setData({
          openid: loginRes.result.openid
        });
      }
    } catch (error) {
      console.error('获取openid失败', error);
    }
  },

  // 返回上一页
  onBack() {
    if (this.data.previewImageUrl) {
      Dialog.confirm({
        title: '确认离开',
        content: '你已经生成了图片，确定要离开吗？',
        confirmBtn: '确定',
        cancelBtn: '取消',
      }).then(() => {
        wx.navigateBack();
      }).catch(() => {
        // 用户取消离开
      });
    } else {
      wx.navigateBack();
    }
  },

  // 处理提示词输入变化
  onPromptTextChange(e: any) {
    this.setData({
      promptText: e.detail.value
    });
  },

  // 处理负面提示词输入变化
  onNegativePromptTextChange(e: any) {
    this.setData({
      negativePromptText: e.detail.value
    });
  },

  // 添加标签词到输入框
  addChip(e: any) {
    const { text, negative } = e.currentTarget.dataset;
    const field = negative ? 'negativePromptText' : 'promptText';
    const currentText = this.data[field] || '';
    
    let newText = '';
    if (currentText.trim() === '') {
      newText = text;
    } else {
      newText = currentText + '，' + text;
    }
    
    this.setData({
      [field]: newText
    });
  },

  // 风格选择变化处理
  onStyleChange(e: any) {
    this.setData({
      style: e.detail.value
    });
    console.log('选择风格:', e.detail.value);
  },

  // 尺寸选择变化处理
  onSizeChange(e: any) {
    this.setData({
      size: e.detail.value
    });
    console.log('选择尺寸:', e.detail.value);
  },

  // 生成图片
  async generateImage() {
    const { promptText, negativePromptText, style, size } = this.data;
    
    if (!promptText || promptText.trim() === '') {
      Toast({
        context: this,
        selector: '#t-toast',
        message: '请输入描述内容',
        theme: 'error',
      });
      return;
    }
    
    // 显示加载状态
    this.setData({
      isGenerating: true,
      generationError: '',
      currentTaskId: '',
      pollCount: 0,
      previewImageUrl: ''
    });
    
    try {
      // 调用云函数创建文生图任务
      const createResult = await wx.cloud.callFunction({
        name: 'textToImage',
        data: {
          name: 'createImageTask',
          data: {
            prompt: promptText,
            negativePrompt: negativePromptText || undefined,
            style: style,
            size: size,
            n: 1 // 每次生成一张图片
          }
        }
      }) as any;
      
      console.log('创建图片任务结果:', createResult);
      
      if (createResult.result && createResult.result.success) {
        const taskData = createResult.result.data;
        const taskId = taskData.output.task_id;
        
        this.setData({
          currentTaskId: taskId
        });
        
        // 开始轮询任务结果
        this.pollTaskResult(taskId);
      } else {
        // 创建任务失败
        this.setData({
          isGenerating: false,
          generationError: createResult.result?.message || '创建任务失败'
        });
        
        Toast({
          context: this,
          selector: '#t-toast',
          message: createResult.result?.message || '创建图片任务失败',
          theme: 'error',
        });
      }
    } catch (error: any) {
      console.error('生成图片错误:', error);
      this.setData({
        isGenerating: false,
        generationError: error.message || '请求失败'
      });
      
      Toast({
        context: this,
        selector: '#t-toast',
        message: '生成图片失败: ' + (error.message || '未知错误'),
        theme: 'error',
      });
    }
  },
  
  // 轮询任务结果
  async pollTaskResult(taskId: string) {
    try {
      const { pollCount } = this.data;
      
      // 超过最大轮询次数，停止轮询
      if (pollCount >= MAX_POLL_COUNT) {
        this.setData({
          isGenerating: false,
          generationError: '生成图片超时，请重试'
        });
        
        Toast({
          context: this,
          selector: '#t-toast',
          message: '生成图片超时，请重试',
          theme: 'error',
        });
        return;
      }
      
      // 调用云函数查询任务结果
      const resultRes = await wx.cloud.callFunction({
        name: 'textToImage',
        data: {
          name: 'getImageResult',
          data: {
            taskId
          }
        }
      }) as any;
      
      console.log('查询任务结果:', resultRes);
      
      if (resultRes.result && resultRes.result.success) {
        const resultData = resultRes.result.data;
        const taskStatus = resultData.output.task_status;
        
        if (taskStatus === 'SUCCEEDED') {
          // 任务成功，获取图片URL
          if (
            resultData.output.results && 
            resultData.output.results.length > 0 && 
            resultData.output.results[0].url
          ) {
            const tempImageUrl = resultData.output.results[0].url;
            
            // 创建图片数据
            const imageData: ImageData = {
              imageUrl: tempImageUrl, // 这是临时URL，将在发布时被云存储URL替换
              promptText: this.data.promptText,
              negativePromptText: this.data.negativePromptText,
              createTime: Date.now(),
              isPublic: false,
              taskId: taskId,
              style: this.data.style,
              size: this.data.size
            };
            
            // 保存到数据中，用于发布时使用
            this.setData({
              previewImageUrl: tempImageUrl,
              isGenerating: false,
              currentImageData: imageData
            });

            // 保存到本地存储，用于结果页面显示
            wx.setStorageSync('currentImageData', imageData);
            
            // 生成成功提示
            Toast({
              context: this,
              selector: '#t-toast',
              message: '图片生成成功',
              theme: 'success',
            });
          } else {
            this.setData({
              isGenerating: false,
              generationError: '图片生成结果为空'
            });
            
            Toast({
              context: this,
              selector: '#t-toast',
              message: '图片生成结果为空',
              theme: 'error',
            });
          }
        } else if (taskStatus === 'FAILED') {
          // 任务失败
          this.setData({
            isGenerating: false,
            generationError: '图片生成失败: ' + (resultData.output.error || '未知错误')
          });
          
          Toast({
            context: this,
            selector: '#t-toast',
            message: '图片生成失败: ' + (resultData.output.error || '未知错误'),
            theme: 'error',
          });
        } else if (taskStatus === 'PENDING' || taskStatus === 'RUNNING') {
          // 任务仍在进行中，继续轮询
          this.setData({
            pollCount: pollCount + 1
          });
          
          setTimeout(() => {
            this.pollTaskResult(taskId);
          }, POLL_INTERVAL);
        } else {
          // 其他状态视为失败
          this.setData({
            isGenerating: false,
            generationError: '未知任务状态: ' + taskStatus
          });
          
          Toast({
            context: this,
            selector: '#t-toast',
            message: '未知任务状态: ' + taskStatus,
            theme: 'error',
          });
        }
      } else {
        // 查询任务失败
        this.setData({
          isGenerating: false,
          generationError: resultRes.result?.message || '查询任务失败'
        });
        
        Toast({
          context: this,
          selector: '#t-toast',
          message: resultRes.result?.message || '查询任务结果失败',
          theme: 'error',
        });
      }
    } catch (error: any) {
      console.error('轮询任务结果错误:', error);
      this.setData({
        isGenerating: false,
        generationError: error.message || '查询任务失败'
      });
      
      Toast({
        context: this,
        selector: '#t-toast',
        message: '查询任务失败: ' + (error.message || '未知错误'),
        theme: 'error',
      });
    }
  },
  
  // 图片预览功能
  previewImage() {
    if (this.data.previewImageUrl) {
      wx.previewImage({
        urls: [this.data.previewImageUrl],
        current: this.data.previewImageUrl
      });
    }
  },
  
  // 重置图片
  resetImage() {
    this.setData({
      previewImageUrl: '',
      currentImageData: null,
      currentTaskId: '',
      pollCount: 0,
      generationError: ''
    });

    // 清除本地存储中的临时图片数据
    wx.removeStorageSync('currentImageData');
  },
  
  // 发布图片
  async publishImage() {
    if (!this.data.currentImageData) {
      Toast({
        context: this,
        selector: '#t-toast',
        message: '请先生成图片',
        theme: 'error',
      });
      return;
    }

    // 显示加载状态
    this.setData({
      isPublishing: true
    });
    
    Toast({
      context: this,
      selector: '#t-toast',
      message: '正在发布...',
      theme: 'loading',
      duration: 1000
    });
    
    try {
      // 将图片保存到云数据库
      const result = await this.saveImageToCloud();
      
      // 更新当前图片数据，使用云存储中的永久URL
      if (result && result._id) {
        const db = wx.cloud.database();
        const imageData = await db.collection('images').doc(result._id).get();
        
        if (imageData && imageData.data) {
          // 更新本地存储和当前数据
          const updatedImageData = imageData.data as unknown as ImageData;
          this.setData({
            currentImageData: updatedImageData,
            previewImageUrl: updatedImageData.imageUrl
          });
          wx.setStorageSync('currentImageData', updatedImageData);
        }
      }
      
      // 发布成功后跳转到首页
      Toast({
        context: this,
        selector: '#t-toast',
        message: '发布成功！',
        theme: 'success',
        duration: 1000,
        onClose: () => {
          this.setData({
            isPublishing: false
          });
          wx.switchTab({
            url: '/pages/index/index'
          });
        }
      });
    } catch (error) {
      console.error('发布图片失败', error);
      this.setData({
        isPublishing: false
      });
      Toast({
        context: this,
        selector: '#t-toast',
        message: '发布失败，请重试',
        theme: 'error',
      });
    }
  },
  
  // 保存图片到云数据库
  async saveImageToCloud() {
    if (!this.data.currentImageData || !this.data.openid) {
      throw new Error('当前图片数据或用户ID不存在');
    }
    
    try {
      // 显示上传进度提示
      wx.showLoading({
        title: '保存图片中...',
        mask: true
      });
      
      const { imageUrl, promptText, negativePromptText, style, size } = this.data.currentImageData;
      
      // 生成云存储路径
      const timestamp = Date.now();
      const cloudPath = `images/${this.data.openid}_${timestamp}.png`;
      
      // 调用云函数下载远程图片并上传到云存储
      const downloadResult = await wx.cloud.callFunction({
        name: 'downloadAndUploadImage',
        data: {
          remoteUrl: imageUrl,
          cloudPath: cloudPath
        }
      }) as any;
      
      console.log('下载上传结果:', downloadResult);
      
      if (!downloadResult.result || !downloadResult.result.success) {
        throw new Error(downloadResult.result?.message || '下载并上传图片失败');
      }
      
      const fileID = downloadResult.result.fileID;
      
      if (!fileID) {
        throw new Error('云存储文件ID为空');
      }
      
      // 3. 准备要存储到数据库的图片数据
      const db = wx.cloud.database();
      const imageData = {
        imageUrl: fileID, // 使用云存储中的文件ID
        promptText: promptText,
        negativePromptText: negativePromptText || '',
        createTime: timestamp,
        updateTime: timestamp,
        isPublic: true,
        style: style || '<auto>',
        size: size || '1024*1024',
        originalUrl: imageUrl // 保存原始URL，以便需要时参考
      };
      
      // 4. 添加到云数据库
      const addResult = await db.collection('images').add({
        data: imageData
      });
      
      wx.hideLoading();
      
      return addResult;
    } catch (error) {
      wx.hideLoading();
      console.error('保存图片到云存储失败:', error);
      throw error;
    }
  }
}) 